home *** CD-ROM | disk | FTP | other *** search
/ Shareware Grab Bag / Shareware Grab Bag.iso / 001 / pibt32s2.arc / PIBDIALB.PAS < prev    next >
Encoding:
Pascal/Delphi Source File  |  1985-11-30  |  21.7 KB  |  658 lines
  1.  
  2. (*----------------------------------------------------------------------*)
  3. (*                  Dial_A_Number --- dial phone number                 *)
  4. (*----------------------------------------------------------------------*)
  5.  
  6. PROCEDURE Dial_A_Number(     Re_Dial : BOOLEAN;
  7.                          VAR Quit    : BOOLEAN );
  8.  
  9. (*----------------------------------------------------------------------*)
  10. (*                                                                      *)
  11. (*     Procedure:  Dial_A_Number                                        *)
  12. (*                                                                      *)
  13. (*     Purpose:    Dials phone number                                   *)
  14. (*                                                                      *)
  15. (*     Calling Sequence:                                                *)
  16. (*                                                                      *)
  17. (*        Dial_A_Number(     Re_Dial : BOOLEAN;                         *)
  18. (*                       VAR Quit    : BOOLEAN );                       *)
  19. (*                                                                      *)
  20. (*           Re_Dial --- TRUE to re-dial last number                    *)
  21. (*           Quit    --- TRUE if Esc key hit to stop dialing            *)
  22. (*                                                                      *)
  23. (*     Calls:   Async_Send_String                                       *)
  24. (*              Save_Screen                                             *)
  25. (*              Restore_Screen                                          *)
  26. (*              Draw_Menu_Frame                                         *)
  27. (*              Reset_Global_Colors                                     *)
  28. (*              Dialer_Carrier_Detect                                   *)
  29. (*              Display_Phone_Numbers                                   *)
  30. (*              TimeOfDay                                               *)
  31. (*              TimeDiff                                                *)
  32. (*                                                                      *)
  33. (*----------------------------------------------------------------------*)
  34.  
  35. VAR
  36.    Dial_Title   : ShortStr;
  37.    OK_Redial    : BOOLEAN;
  38.    Ch           : CHAR;
  39.    Timed_Out    : BOOLEAN;
  40.    STimer       : REAL;
  41.    Modem_Mess   : AnyStr;
  42.    New_Baud     : INTEGER;
  43.    Ierr         : INTEGER;
  44.    Qerr         : BOOLEAN;
  45.    SNumber      : STRING[100];
  46.    Inumber      : INTEGER;
  47.    Modem_Buzy   : BOOLEAN;
  48.    Modem_NoC    : BOOLEAN;
  49.    T            : REAL;
  50.    TOD          : REAL;
  51.    IY           : INTEGER;
  52.    I            : INTEGER;
  53.    J            : INTEGER;
  54.    TS           : STRING[9];
  55.    TSO          : STRING[9];
  56.    ESC_Hit      : BOOLEAN;
  57.    Local_Save_3 : Saved_Screen_Ptr;
  58.    Local_Save_5 : Saved_Screen_Ptr;
  59.    Got_Num      : BOOLEAN;
  60.    CR_Str       : STRING[1];
  61.    Do_Baud      : BOOLEAN;
  62.    I_Dial_Nos   : INTEGER;
  63.  
  64. (*----------------------------------------------------------------------*)
  65. (*  Convert_Entry_To_Number --- convert dialing entry to phone number   *)
  66. (*----------------------------------------------------------------------*)
  67.  
  68. OVERLAY PROCEDURE Convert_Entry_To_Number;
  69.  
  70. BEGIN (* Convert_Entry_To_Number *)
  71.  
  72.                                    (* Check for manual dial *)
  73.  
  74.    IF UpCase( SNumber[1] ) = 'M' THEN
  75.       BEGIN
  76.          Manual_Dial := TRUE;
  77.          IF LENGTH( SNumber ) > 1 THEN
  78.             SNumber     := COPY( SNumber, 2, LENGTH( SNumber ) - 1 )
  79.          ELSE
  80.             SNumber     := '';
  81.       END;
  82.                                    (* Check for prefix *)
  83.  
  84.    IF SNumber[1] IN ['+','-','!','@','#'] THEN
  85.       BEGIN
  86.          Prefix_Str := Phone_Prefix_Nos[ POS( SNumber[1], '+-!@#' ) ];
  87.          IF LENGTH( SNumber ) > 1 THEN
  88.             SNumber    := COPY( SNumber, 2, LENGTH( SNumber ) - 1 )
  89.          ELSE
  90.             SNumber     := '';
  91.       END;
  92.  
  93.    IF SNumber[LENGTH(SNumber)] IN ['+','-','!','@','#'] THEN
  94.       BEGIN
  95.          Postfix_Str := Phone_Prefix_Nos[ POS( SNumber[LENGTH(SNumber)],
  96.                                                '+-!@#' ) ];
  97.          IF LENGTH( SNumber ) > 1 THEN
  98.             SNumber    := COPY( SNumber, 1, ( LENGTH( SNumber ) - 1 ) )
  99.          ELSE
  100.             SNumber     := '';
  101.       END;
  102.  
  103.    IF Manual_Dial THEN
  104.       BEGIN
  105.          Phone_Number := SNumber;
  106.          FOR I := 1 TO 25 DO
  107.             Phone_Entry_Data.Phone_Name[I] := ' ';
  108.       END
  109.    ELSE
  110.       BEGIN
  111.          Inumber := 2;
  112.          VAL( SNumber, Inumber, Ierr );
  113.          IF ( Ierr = 0 ) AND
  114.             ( INumber > 0 ) AND
  115.             ( INumber < Default_Phone_Number_Size) THEN
  116.             BEGIN
  117.                SEEK( Phone_File , Inumber - 1 );
  118.                READ( Phone_File , Phone_Entry_Data );
  119.                Phone_Number := Phone_Entry_Data.Phone_Number;
  120.                IF ( NOT Dialer_Carrier_Detect ) THEN
  121.                   Reset_Comm_Params( Phone_Entry_Data );
  122.             END
  123.          ELSE
  124.             BEGIN
  125.                WRITELN;
  126.                WRITE('Bad phone number, dialing cancelled.');
  127.                ClrEol;
  128.                DELAY( Two_Second_Delay );
  129.                Quit := TRUE;
  130.             END;
  131.       END;
  132.  
  133. END   (* Convert_Entry_To_Number *);
  134.  
  135. (*----------------------------------------------------------------------*)
  136. (*            Perform_The_Dial --- perform actual dialing               *)
  137. (*----------------------------------------------------------------------*)
  138.  
  139. OVERLAY PROCEDURE Perform_The_Dial;
  140.  
  141. BEGIN (* Perform_The_Dial *)
  142.  
  143.    Modem_Mess  := '';
  144.  
  145.    IF ( LENGTH( Phone_Number ) > 0 ) AND ( NOT Quit ) THEN
  146.       BEGIN  (* Phone number gotten *)
  147.  
  148.          Window( 1, 1, 80, 25 );
  149.  
  150.          IF ( NOT Manual_Dial ) THEN
  151.             Dial_Title := TRIM( Dial_Title + ' ' +
  152.                                 Phone_Entry_Data.Phone_Name );
  153.  
  154.          Draw_Menu_Frame( 10, 10, 60, 16, Menu_Frame_Color,
  155.                           Menu_Text_Color, Dial_Title );
  156.  
  157.          GoToXY( 1 , 1 );
  158.                                    (* Purge receive to avoid *)
  159.                                    (* false modem messages   *)
  160.          Async_Purge_Buffer;
  161.  
  162.          IF OK_Redial THEN
  163.             WRITE('Re-dialing: ', Prefix_Str + Phone_Number + Postfix_Str )
  164.          ELSE
  165.             WRITE('Dialing: ', Prefix_Str + Phone_Number + Postfix_Str );
  166.  
  167.          ClrEol;
  168.  
  169.          IF LENGTH( Postfix_Str ) > 0 THEN
  170.             IF Postfix_Str[ LENGTH( Postfix_Str ) ] <> CHR( CR ) THEN
  171.                CR_Str := CHR( CR )
  172.             ELSE
  173.                CR_Str := ''
  174.          ELSE
  175.             CR_Str := CHR( CR );
  176.  
  177.          Async_Send_String( Modem_Dial + Prefix_Str + Phone_Number +
  178.                             Postfix_Str + CR_Str );
  179.  
  180.          STimer     := TimeOfDay;
  181.          Modem_Buzy := FALSE;
  182.          Modem_NoC  := FALSE;
  183.          IY         := WhereY;
  184.          TS         := '';
  185.  
  186.          GoToXY( 1 , 2 );
  187.          WRITE('Dialing begins at:    ',TimeString(TimeOfDay));
  188.          ClrEol;
  189.  
  190.          GoToXY( 1 , 3 );
  191.          WRITE('Elapsed dialing time: ');
  192.          ClrEol;
  193.  
  194.          REPEAT
  195.  
  196.             TOD       := TimeOfDay;
  197.             T         := TimeDiff( STimer , TOD );
  198.             TSO       := TS;
  199.             TS        := TimeString( T );
  200.  
  201.             IF TS <> TSO THEN
  202.                BEGIN
  203.                   GoToXY( 23 , 3 );
  204.                   WRITE( TS );
  205.                   ClrEol;
  206.                END;
  207.  
  208.             Timed_Out := ( T > Modem_Time_Out );
  209.  
  210.             IF Async_Receive( Ch ) THEN
  211.                Modem_Mess := Modem_Mess + Ch;
  212.  
  213.             Modem_Buzy := ( POS( Modem_Busy       , Modem_Mess ) > 0 ) AND
  214.                           ( LENGTH( Modem_Busy )  > 0 );
  215.             Modem_NoC  := ( POS( Modem_No_Carrier , Modem_Mess ) > 0 ) AND
  216.                           ( LENGTH( Modem_No_Carrier ) > 0 );
  217.  
  218.             Esc_Hit := FALSE;
  219.  
  220.             IF KeyPressed THEN
  221.                BEGIN
  222.  
  223.                   READ( Kbd, Ch );
  224.  
  225.                   IF Ch = CHR( ESC ) THEN
  226.                      Esc_Hit := TRUE;
  227.  
  228.                   WHILE( KeyPressed ) DO
  229.                      READ( Kbd, Ch );
  230.  
  231.                END;
  232.  
  233.          UNTIL ( Async_Carrier_Detect ) OR
  234.                ( Timed_Out            ) OR
  235.                ( Modem_Buzy           ) OR
  236.                ( Modem_NoC            ) OR
  237.                ( Esc_Hit              );
  238.  
  239.          IF Esc_Hit THEN
  240.             BEGIN
  241.  
  242.                GoToXY( 1 , WhereY );
  243.  
  244.                WRITE('*** ESC Pressed, Dialing Aborted.');
  245.                ClrEol;
  246.                                    (* Hang up the phone *)
  247.                HangUpPhone;
  248.  
  249.             END
  250.          ELSE IF Timed_Out THEN
  251.             BEGIN
  252.  
  253.                GoToXY( 1 , WhereY );
  254.                WRITE('*** Modem Timed Out, Dialing Aborted.');
  255.                ClrEol;
  256.  
  257.                DELAY( One_Second_Delay );
  258.  
  259.             END
  260.          ELSE IF Modem_Buzy THEN
  261.             BEGIN
  262.  
  263.                GoToXY( 1 , WhereY );
  264.  
  265.                WRITE('*** Line busy');
  266.                ClrEol;
  267.                                    (* Hang up the phone *)
  268.                HangUpPhone;
  269.  
  270.                DELAY( One_Second_Delay );
  271.  
  272.             END
  273.          ELSE IF Modem_NoC THEN
  274.             BEGIN
  275.  
  276.                GoToXY( 1 , WhereY );
  277.  
  278.                WRITE('*** No answer');
  279.                ClrEol;
  280.                                    (* Hang up the phone *)
  281.                HangUpPhone;
  282.  
  283.                DELAY( One_Second_Delay );
  284.  
  285.             END;
  286.  
  287.       END  (* Phone number gotten *);
  288.  
  289.    IF ( Async_Carrier_Detect AND ( NOT Quit ) ) THEN
  290.       BEGIN  (* Carrier detected *)
  291.  
  292.          STimer     := TimeOfDay;
  293.  
  294.          REPEAT
  295.  
  296.             Timed_Out := TimeDiff( Stimer , TimeOfDay ) > 3.0;
  297.  
  298.             IF Async_Receive( Ch ) THEN
  299.                Modem_Mess := Modem_Mess + Ch;
  300.  
  301.          UNTIL( Ch = CHR( CR ) ) OR ( Timed_Out );
  302.  
  303.          IY     := 0;
  304.  
  305.          IF( LENGTH( Modem_Connect ) > 0 ) THEN
  306.             IY     := POS( Modem_Connect , Modem_Mess );
  307.  
  308.          IF ( IY > 0 ) THEN
  309.             BEGIN
  310.  
  311.                I             := IY + LENGTH( Modem_Connect ) + 1;
  312.                Modem_Mess    := Modem_Mess + CHR( CR );
  313.                New_Baud      := 0;
  314.                Do_Baud       := TRUE;
  315.  
  316.                WHILE( Do_Baud ) DO
  317.                   BEGIN
  318.                      IF Modem_Mess[I] IN ['0'..'9'] THEN
  319.                         New_Baud := New_Baud * 10 + ORD( Modem_Mess[I] ) -
  320.                                                     ORD('0')
  321.                      ELSE IF Modem_Mess[I] = CHR( CR ) THEN
  322.                         Do_Baud := FALSE;
  323.                      I := I + 1;
  324.                      IF ( I > LENGTH( Modem_Mess ) ) THEN
  325.                         Do_Baud := FALSE;
  326.                   END;
  327.  
  328.                IF ( New_Baud <> Baud_Rate ) AND
  329.                   ( New_Baud  > 0         ) AND
  330.                   ( Alter_Baud_Rate       ) THEN
  331.                   BEGIN
  332.                      Baud_Rate := New_Baud;
  333.                      Async_Reset_Port( Comm_Port, Baud_Rate, Parity,
  334.                                        Data_Bits, Stop_Bits );
  335.                   END;
  336.  
  337.             END;
  338.  
  339.          Restore_Screen( Local_Save_5 );
  340.          Reset_Global_Colors;
  341.  
  342.          WRITELN;
  343.          WRITELN('Connection established at ',Baud_Rate,',',Parity,',',
  344.                  Data_Bits,',',Stop_Bits);
  345.  
  346.       END (* Carrier detected *);
  347.  
  348. END   (* Perform_The_Dial *);
  349.  
  350. (*----------------------------------------------------------------------*)
  351.  
  352. BEGIN (* Dial_A_Number *)
  353.  
  354.    Manual_Dial := FALSE;
  355.    Quit        := FALSE;
  356.    Got_Num     := FALSE;
  357.    N_Dial_Nos  := 0;
  358.  
  359.    OK_Redial := Re_Dial AND ( Phone_Number <> '' );
  360.  
  361.    IF OK_Redial THEN
  362.       Dial_Title := 'Redialing'
  363.    ELSE
  364.       Dial_Title := 'Dialing';
  365.  
  366.    Save_Screen( Local_Save_5 );
  367.  
  368.    IF NOT OK_Redial THEN
  369.       BEGIN  (* Not a redial *)
  370.  
  371.                                    (* No dialing string given -- display *)
  372.                                    (* directory.                         *)
  373.  
  374.          IF LENGTH( Dialing_String ) = 0 THEN
  375.             BEGIN
  376.  
  377.                Display_Phone_Numbers( Phone_Number, Prefix_Str, Postfix_Str,
  378.                                       Quit );
  379.  
  380.                IF Dialer_Carrier_Detect OR Quit OR ReDial OR
  381.                   ( ( LENGTH( Phone_Number ) = 0 ) AND
  382.                     ( N_Dial_Nos = 0             )     ) THEN
  383.                   BEGIN
  384.                      Restore_Screen( Local_Save_5 );
  385.                      Reset_Global_Colors;
  386.                      EXIT;
  387.                   END
  388.                ELSE
  389.                   Got_Num := TRUE;
  390.  
  391.             END
  392.          ELSE                      (* Dialing string provided *)
  393.             BEGIN
  394.                SNumber     := Dialing_String;
  395.                Prefix_Str  := '';
  396.                Postfix_Str := '';
  397.                FOR I := 1 TO 25 DO
  398.                   Phone_Entry_Data.Phone_Name[I] := ' ';
  399.             END;
  400.  
  401.          IF ( NOT Quit ) THEN
  402.             IF ( NOT Got_Num ) THEN
  403.                Convert_Entry_To_Number;
  404.  
  405.       END  (* Not a redial *);
  406.  
  407.    IF ( Dialer_Carrier_Detect AND ( NOT Quit ) ) THEN
  408.       BEGIN
  409.          Save_Screen( Local_Save_3 );
  410.          Window( 1, 1, 80, 25 );
  411.          Draw_Menu_Frame( 10, 5, 60, 8, Menu_Frame_Color,
  412.                           Menu_Text_Color + Blink, '' );
  413.          WRITE('Session already in progress, dialing aborted.');
  414.          DELAY( Two_Second_Delay );
  415.          Restore_Screen( Local_Save_3 );
  416.          Reset_Global_Colors;
  417.          Restore_Screen( Local_Save_5 );
  418.          Reset_Global_Colors;
  419.          EXIT;
  420.       END;
  421.                                    (* Do actual dialing *)
  422.    IF N_Dial_Nos = 0 THEN
  423.                                    (* Single entry *)
  424.       Perform_The_Dial
  425.    ELSE
  426.       BEGIN
  427.                                    (* List of entries *)
  428.          I_Dial_Nos := 0;
  429.  
  430.          REPEAT                    (* Get next # in dialing list *)
  431.  
  432.             I_Dial_Nos := I_Dial_Nos + 1;
  433.             IF ( I_Dial_Nos > N_Dial_Nos ) THEN
  434.                I_Dial_Nos := 1;
  435.  
  436.             SNumber     := Dial_Nos[I_Dial_Nos];
  437.             Manual_Dial := FALSE;
  438.             Dial_Title  := 'Dialing';
  439.  
  440.                                    (* Convert to dialable form *)
  441.  
  442.             Convert_Entry_To_Number;
  443.  
  444.                                    (* Do the dialing *)
  445.             Perform_The_Dial;
  446.  
  447.          UNTIL ( Async_Carrier_Detect OR Quit OR ESC_Hit );
  448.  
  449.       END;
  450.                                    (* Restore previous screen *)
  451.                                    (* if not connected        *)
  452.  
  453.    IF ( NOT Async_Carrier_Detect ) THEN
  454.       BEGIN
  455.          Restore_Screen( Local_Save_5 );
  456.          Reset_Global_Colors;
  457.       END;
  458.                                    (* Make sure phone hung up *)
  459.                                    (* if unsuccessful dial    *)
  460.    IF Quit THEN
  461.       HangUpPhone;
  462.  
  463. END   (* Dial_A_Number *);
  464.  
  465. (*----------------------------------------------------------------------*)
  466. (*          Redial_A_Number --- Redial last phone number dialed         *)
  467. (*----------------------------------------------------------------------*)
  468.  
  469. PROCEDURE Redial_A_Number;
  470.  
  471. (*----------------------------------------------------------------------*)
  472. (*                                                                      *)
  473. (*     Procedure:  Redial_A_Number                                      *)
  474. (*                                                                      *)
  475. (*     Purpose:    Redials last number dialed (if any).                 *)
  476. (*                                                                      *)
  477. (*     Calling Sequence:                                                *)
  478. (*                                                                      *)
  479. (*        Redial_A_Number;                                              *)
  480. (*                                                                      *)
  481. (*     Calls:                                                           *)
  482. (*                                                                      *)
  483. (*        Dial_A_Number                                                 *)
  484. (*        TimeOfDay                                                     *)
  485. (*        TimeDiff                                                      *)
  486. (*        Dialer_Carrier_Detect                                         *)
  487. (*        Clear_Window                                                  *)
  488. (*                                                                      *)
  489. (*----------------------------------------------------------------------*)
  490.  
  491. VAR
  492.    RTimer       : REAL;
  493.    DTimer       : REAL;
  494.    PTimer       : REAL;
  495.    OTimer       : REAL;
  496.    Done         : BOOLEAN;
  497.    Rchar        : CHAR;
  498.    MDelay       : REAL;
  499.    MDnew        : REAL;
  500.    Ypos         : INTEGER;
  501.    Local_Save_5 : Saved_Screen_Ptr;
  502.    Quit         : BOOLEAN;
  503.  
  504. BEGIN (* Redial_A_Number *)
  505.                                    (* Only redial if no current session *)
  506.  
  507.    Done       := Dialer_Carrier_Detect OR ( Phone_Number = '' );
  508.  
  509.    MDelay     := Modem_Redial_Delay;
  510.  
  511.    WHILE( NOT Done ) DO
  512.       BEGIN
  513.                                    (* Redial the number *)
  514.  
  515.          Dial_A_Number( TRUE , Quit );
  516.  
  517.                                    (* If connection established, done *)
  518.  
  519.          Done   := Async_Carrier_Detect;
  520.  
  521.                                    (* Otherwise, wait for specified   *)
  522.                                    (* modem delay                     *)
  523.          IF ( NOT Done ) THEN
  524.             BEGIN
  525.  
  526.                Save_Screen( Local_Save_5 );
  527.                Draw_Menu_Frame( 10, 10, 60, 16, Menu_Frame_Color,
  528.                                 Menu_Text_Color, 'Redialing' );
  529.  
  530.                RTimer := TimeOfDay;
  531.  
  532.                Clear_Window;
  533.  
  534.                Ypos := WhereY;
  535.  
  536.                WRITELN(' Seconds to next redial: ', TRUNC( MDelay ) );
  537.                WRITE  (' R = redial now   Esc = stop   C = change delay.');
  538.  
  539.                Rchar  := ' ';
  540.                PTimer := MDelay;
  541.                OTimer := PTimer;
  542.  
  543.                REPEAT
  544.  
  545.                   IF PTimer <> OTimer THEN
  546.                      BEGIN
  547.                         GoToXY( 26 , YPos );
  548.                         WRITE( TRUNC( PTimer ) );
  549.                         ClrEol;
  550.                         OTimer := PTimer;
  551.                      END;
  552.  
  553.                   IF KeyPressed THEN
  554.                      BEGIN
  555.  
  556.                         READ( Kbd , Rchar );
  557.  
  558.                         IF UpCase( Rchar ) = 'C' THEN
  559.                            BEGIN
  560.                               GotoXY( 1 , 3 );
  561.                               WRITE  (' Enter new delay: ');
  562.                               ClrEol;
  563.                                  (*$I-*)
  564.                               READLN( MDNew );
  565.                                  (*$I+*)
  566.                               IF Int24Result = 0 THEN
  567.                                  MDelay := MDNew;
  568.                               GoToXY( 1 , 3 );
  569.                               ClrEol;
  570.                            END
  571.                         ELSE IF ( Rchar = CHR( ESC ) ) THEN
  572.                            Rchar := 'X';
  573.  
  574.                      END;
  575.  
  576.                   DTimer := TimeDiff( RTimer , TimeOfDay );
  577.  
  578.                   PTimer := MDelay - DTimer;
  579.                   IF PTimer <= 0.0 THEN
  580.                      PTimer := 0.0;
  581.  
  582.                UNTIL ( DTimer > MDelay ) OR
  583.                      ( UpCase( Rchar ) IN ['R','X'] );
  584.  
  585.                Done := ( UpCase(Rchar) = 'X' );
  586.  
  587.                Restore_Screen( Local_Save_5 );
  588.                Reset_Global_Colors;
  589.  
  590.             END (* NOT Done *)
  591.          ELSE
  592.             IF ( NOT Script_File_Mode ) THEN
  593.                BEGIN
  594.  
  595.                   Save_Screen( Local_Save_5 );
  596.                   Draw_Menu_Frame( 10, 10, 60, 14, Menu_Frame_Color,
  597.                                    Menu_Text_Color + Blink, '' );
  598.  
  599.                   WRITELN('Connection established!!');
  600.                   WRITE  ('Hit any key to continue');
  601.  
  602.                   REPEAT
  603.                      Menu_Beep;
  604.                      DELAY( 3 * Tenth_Of_A_Second_Delay );
  605.                   UNTIL( KeyPressed );
  606.  
  607.                   READ( Kbd , RChar );
  608.                   IF ( RChar = CHR( ESC ) ) AND KeyPressed THEN
  609.                      READ( Kbd, RChar );
  610.  
  611.                   Restore_Screen( Local_Save_5 );
  612.                   Reset_Global_Colors;
  613.  
  614.                END;
  615.  
  616.       END (* NOT Done *);
  617.  
  618. END   (* Redial_A_Number *);
  619.  
  620. (*------------------------- PIBDIALER --------------------------------*)
  621.  
  622. BEGIN (* PibDialer *)
  623.                                    (* Open phone file for later use *)
  624.  
  625.    ASSIGN( Phone_File, Home_Dir + 'PIBTERM.FON' );
  626.         (*$I-*)
  627.    RESET( Phone_File );
  628.         (*$I+*)
  629.                                    (* Determine if dial or redial   *)
  630.    CASE ReDial OF
  631.  
  632.       FALSE:  REPEAT
  633.                  Dial_A_Number( FALSE , Quit );
  634.                  Quit := Quit OR Script_File_Mode;
  635.                  IF ( ReDial AND ( NOT Quit ) ) THEN
  636.                     BEGIN
  637.                        ReDial_A_Number;
  638.                        Redial := FALSE;
  639.                     END;
  640.               UNTIL ( Async_Carrier_Detect OR Quit );
  641.  
  642.       TRUE:   BEGIN
  643.                  IF Phone_Number = '' THEN
  644.                     Dial_A_Number( FALSE , Quit );
  645.                  ReDial_A_Number;
  646.               END;
  647.  
  648.    END (* CASE *);
  649.                                    (* Close phone file when done *)
  650.       (*$I-*)
  651.    CLOSE( Phone_File );
  652.       (*$I+*)
  653.                                    (* Reset timer if connection made *)
  654.    IF Async_Carrier_Detect THEN
  655.       Dialing_Start_Time := TimeOfDay;
  656.  
  657. END   (* PibDialer *);
  658.